home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / simplejson / encoder.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  7KB  |  308 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import re
  5.  
  6. try:
  7.     from simplejson._speedups import encode_basestring_ascii as c_encode_basestring_ascii
  8. except ImportError:
  9.     c_encode_basestring_ascii = None
  10.  
  11. ESCAPE = re.compile('[\\x00-\\x1f\\\\"\\b\\f\\n\\r\\t]')
  12. ESCAPE_ASCII = re.compile('([\\\\"]|[^\\ -~])')
  13. HAS_UTF8 = re.compile('[\\x80-\\xff]')
  14. ESCAPE_DCT = {
  15.     '\\': '\\\\',
  16.     '"': '\\"',
  17.     '\x08': '\\b',
  18.     '\x0c': '\\f',
  19.     '\n': '\\n',
  20.     '\r': '\\r',
  21.     '\t': '\\t' }
  22. for i in range(32):
  23.     ESCAPE_DCT.setdefault(chr(i), '\\u%04x' % (i,))
  24.  
  25. INFINITY = float('1e66666')
  26. FLOAT_REPR = repr
  27.  
  28. def floatstr(o, allow_nan = True):
  29.     if o != o:
  30.         text = 'NaN'
  31.     elif o == INFINITY:
  32.         text = 'Infinity'
  33.     elif o == -INFINITY:
  34.         text = '-Infinity'
  35.     else:
  36.         return FLOAT_REPR(o)
  37.     if not allow_nan:
  38.         raise ValueError('Out of range float values are not JSON compliant: %r' % (o,))
  39.     
  40.     return text
  41.  
  42.  
  43. def encode_basestring(s):
  44.     
  45.     def replace(match):
  46.         return ESCAPE_DCT[match.group(0)]
  47.  
  48.     return '"' + ESCAPE.sub(replace, s) + '"'
  49.  
  50.  
  51. def py_encode_basestring_ascii(s):
  52.     if isinstance(s, str) and HAS_UTF8.search(s) is not None:
  53.         s = s.decode('utf-8')
  54.     
  55.     
  56.     def replace(match):
  57.         s = match.group(0)
  58.         
  59.         try:
  60.             return ESCAPE_DCT[s]
  61.         except KeyError:
  62.             n = ord(s)
  63.             if n < 65536:
  64.                 return '\\u%04x' % (n,)
  65.             else:
  66.                 n -= 65536
  67.                 s1 = 55296 | n >> 10 & 1023
  68.                 s2 = 56320 | n & 1023
  69.                 return '\\u%04x\\u%04x' % (s1, s2)
  70.         except:
  71.             n < 65536
  72.  
  73.  
  74.     return '"' + str(ESCAPE_ASCII.sub(replace, s)) + '"'
  75.  
  76. if not c_encode_basestring_ascii:
  77.     pass
  78. encode_basestring_ascii = py_encode_basestring_ascii
  79.  
  80. class JSONEncoder(object):
  81.     __all__ = [
  82.         '__init__',
  83.         'default',
  84.         'encode',
  85.         'iterencode']
  86.     item_separator = ', '
  87.     key_separator = ': '
  88.     
  89.     def __init__(self, skipkeys = False, ensure_ascii = True, check_circular = True, allow_nan = True, sort_keys = False, indent = None, separators = None, encoding = 'utf-8', default = None):
  90.         self.skipkeys = skipkeys
  91.         self.ensure_ascii = ensure_ascii
  92.         self.check_circular = check_circular
  93.         self.allow_nan = allow_nan
  94.         self.sort_keys = sort_keys
  95.         self.indent = indent
  96.         self.current_indent_level = 0
  97.         if separators is not None:
  98.             (self.item_separator, self.key_separator) = separators
  99.         
  100.         if default is not None:
  101.             self.default = default
  102.         
  103.         self.encoding = encoding
  104.  
  105.     
  106.     def _newline_indent(self):
  107.         return '\n' + ' ' * self.indent * self.current_indent_level
  108.  
  109.     
  110.     def _iterencode_list(self, lst, markers = None):
  111.         if not lst:
  112.             yield '[]'
  113.             return None
  114.         
  115.         if markers is not None:
  116.             markerid = id(lst)
  117.             if markerid in markers:
  118.                 raise ValueError('Circular reference detected')
  119.             
  120.             markers[markerid] = lst
  121.         
  122.         yield '['
  123.         if self.indent is not None:
  124.             self.current_indent_level += 1
  125.             newline_indent = self._newline_indent()
  126.             separator = self.item_separator + newline_indent
  127.             yield newline_indent
  128.             self
  129.         else:
  130.             newline_indent = None
  131.             separator = self.item_separator
  132.         first = True
  133.         for value in lst:
  134.             if first:
  135.                 first = False
  136.             else:
  137.                 yield separator
  138.             for chunk in self._iterencode(value, markers):
  139.                 yield chunk
  140.             
  141.         
  142.         if newline_indent is not None:
  143.             self.current_indent_level -= 1
  144.             yield self._newline_indent()
  145.             self
  146.         
  147.         yield ']'
  148.         if markers is not None:
  149.             del markers[markerid]
  150.         
  151.  
  152.     
  153.     def _iterencode_dict(self, dct, markers = None):
  154.         if not dct:
  155.             yield '{}'
  156.             return None
  157.         
  158.         if markers is not None:
  159.             markerid = id(dct)
  160.             if markerid in markers:
  161.                 raise ValueError('Circular reference detected')
  162.             
  163.             markers[markerid] = dct
  164.         
  165.         yield '{'
  166.         key_separator = self.key_separator
  167.         if self.indent is not None:
  168.             self.current_indent_level += 1
  169.             newline_indent = self._newline_indent()
  170.             item_separator = self.item_separator + newline_indent
  171.             yield newline_indent
  172.             self
  173.         else:
  174.             newline_indent = None
  175.             item_separator = self.item_separator
  176.         first = True
  177.         if self.ensure_ascii:
  178.             encoder = encode_basestring_ascii
  179.         else:
  180.             encoder = encode_basestring
  181.         allow_nan = self.allow_nan
  182.         _encoding = self.encoding
  183.         if _encoding is not None:
  184.             pass
  185.         _do_decode = not (_encoding == 'utf-8')
  186.         for key, value in items:
  187.             if isinstance(key, str):
  188.                 if _do_decode:
  189.                     key = key.decode(_encoding)
  190.                 
  191.             elif isinstance(key, basestring):
  192.                 pass
  193.             elif isinstance(key, float):
  194.                 key = floatstr(key, allow_nan)
  195.             elif isinstance(key, (int, long)):
  196.                 key = str(key)
  197.             elif key is True:
  198.                 key = 'true'
  199.             elif key is False:
  200.                 key = 'false'
  201.             elif key is None:
  202.                 key = 'null'
  203.             elif self.skipkeys:
  204.                 continue
  205.             else:
  206.                 raise TypeError('key %r is not a string' % (key,))
  207.             if first:
  208.                 first = False
  209.             else:
  210.                 yield item_separator
  211.             yield encoder(key)
  212.             yield key_separator
  213.             for chunk in self._iterencode(value, markers):
  214.                 yield chunk
  215.             
  216.         
  217.         if newline_indent is not None:
  218.             self.current_indent_level -= 1
  219.             yield self._newline_indent()
  220.             self
  221.         
  222.         yield '}'
  223.         if markers is not None:
  224.             del markers[markerid]
  225.         
  226.  
  227.     
  228.     def _iterencode(self, o, markers = None):
  229.         if isinstance(o, basestring):
  230.             if self.ensure_ascii:
  231.                 encoder = encode_basestring_ascii
  232.             else:
  233.                 encoder = encode_basestring
  234.             _encoding = self.encoding
  235.             if _encoding is not None and isinstance(o, str) and not (_encoding == 'utf-8'):
  236.                 o = o.decode(_encoding)
  237.             
  238.             yield encoder(o)
  239.         elif o is None:
  240.             yield 'null'
  241.         elif o is True:
  242.             yield 'true'
  243.         elif o is False:
  244.             yield 'false'
  245.         elif isinstance(o, (int, long)):
  246.             yield str(o)
  247.         elif isinstance(o, float):
  248.             yield floatstr(o, self.allow_nan)
  249.         elif isinstance(o, (list, tuple)):
  250.             for chunk in self._iterencode_list(o, markers):
  251.                 yield chunk
  252.             
  253.         elif isinstance(o, dict):
  254.             for chunk in self._iterencode_dict(o, markers):
  255.                 yield chunk
  256.             
  257.         elif markers is not None:
  258.             markerid = id(o)
  259.             if markerid in markers:
  260.                 raise ValueError('Circular reference detected')
  261.             
  262.             markers[markerid] = o
  263.         
  264.         for chunk in self._iterencode_default(o, markers):
  265.             yield chunk
  266.         
  267.         if markers is not None:
  268.             del markers[markerid]
  269.         
  270.  
  271.     
  272.     def _iterencode_default(self, o, markers = None):
  273.         newobj = self.default(o)
  274.         return self._iterencode(newobj, markers)
  275.  
  276.     
  277.     def default(self, o):
  278.         raise TypeError('%r is not JSON serializable' % (o,))
  279.  
  280.     
  281.     def encode(self, o):
  282.         if isinstance(o, basestring):
  283.             if isinstance(o, str):
  284.                 _encoding = self.encoding
  285.                 if _encoding is not None and not (_encoding == 'utf-8'):
  286.                     o = o.decode(_encoding)
  287.                 
  288.             
  289.             if self.ensure_ascii:
  290.                 return encode_basestring_ascii(o)
  291.             else:
  292.                 return encode_basestring(o)
  293.         
  294.         chunks = list(self.iterencode(o))
  295.         return ''.join(chunks)
  296.  
  297.     
  298.     def iterencode(self, o):
  299.         if self.check_circular:
  300.             markers = { }
  301.         else:
  302.             markers = None
  303.         return self._iterencode(o, markers)
  304.  
  305.  
  306. __all__ = [
  307.     'JSONEncoder']
  308.